Rational Apex

Rational Apex(TM) brings tightly integrated, interactive, and highly automated support for modern software-engineering practices to your Ada development projects. Available on leading open-systems platforms including IBM RS/6000 and Sun SPARC, Rational Apex cuts the costs, reduces the risks, and improves the quality of your projects, far more than is possible with the conventional approach of loosely integrated tools. Rational Apex is a fundamental component of Rational's modern, Ada-based, software-engineering solution, which comprises a set of software processes, products, and services that give you control of your software-development efforts and sharpen your competitive edge.

Improves the productivity of individual developers
Improves quality by automating many tedious and error-prone tasks
Saves time with optimal recompilation
Ensures consistency of all project-related data
Enforces your software architecture
Scales well from small projects to those with millions of lines of code
Works with all Ada compilers from all vendors
Is tightly integrated with Rational's VADS compiler family
Is easy to learn and use
Is based on industry open-systems standards

Improves your productivity through tight tool integration

Rational Apex replaces the conventional edit, batch-compile, debug approach with an interactive, editor-based model. The Rational model is based on a fine-grained, integrated persistent program representation that captures and manages information about your programs and makes the information available to many tools. No manual step is ever required to pass information from one tool to the next. There are no inconsistent duplicate copies of information to cause errors.

The persistent program representation is based on DIANA, an industry standard for the representation of Ada programs. Rational has augmented DIANA to manage all details about the program, including requirements, design, and code. Rational Apex uses this information to automate many tedious and error-prone tasks, such as syntactic and semantic completion of program fragments and computation of the correct and minimal compilation order.

Saves time and prevents errors during coding

Rational Apex's Ada editor, based on the Motif text widget, provides program templates and formats your program on demand while you enter it. Semantic completion warns you immediately if you violate the semantics of the language, and it shows you the options for legal parameter types. Full semantic information is available even as you build a program from scratch.

The syntactic checking and semantic functions of the editor save you time in writing new code. They also prevent errors that otherwise would be detected only when you attempt to compile your source code.

Makes your program structure understandable

The Ada editor offers interactive hypertext Ada browsing. You can visit the place where any object is declared or defined. You can see immediately all places where a given type or object is used, even across compilation units. You can quickly determine the impact of possible source-code changes.

The queries are always accurate and are never confused by Ada overloading or by reference to a variable in a comment. Rational Apex gives you a powerful and convenient way to navigate through your programs, making it easier to build, learn, and maintain them.

Supports Ada and mixed-language programs

Rational Apex includes a full Ada compiler and debugger for the IBM RS/6000 and the Sun SPARC. The compiler, built on Rational Ada technology in use since 1985, is mature and reliable. The Rational Apex debugger gives you control over all language features, including Ada generics, tasking, and exceptions.

Recognizing that most large Ada programs include some code written in other languages, Rational Apex lets you link code written in assembler, C, or other languages following the standard calling conventions on the RS/6000 or the SPARC. The Rational Apex debugger also handles C code and assembly code. You can set source-level breakpoints and step at the level of C and assembler, in addition to debugging Ada at the source level.

Slashes edit-compile-debug turnaround time

Ada's strict enforcement of interunit consistency checking is one of its great benefits, because it catches errors at compile time that other languages hide until execution time. However, this consistency checking requires extensive recompilation in conventional systems. Any time an Ada specification changes, all Ada units that depend on the changed specification must be recompiled.

Rational Apex uses optimal recompilation to give you the full safety of Ada's consistency checks while drastically reducing the amount of recompilation. With optimal recompilation, you can add declarations to a package specification, remove an unused declaration, or insert a few lines of comments, without causing the recompilation of any of the dependent units. In each case, the Rational Apex compiler uses the information in the persistent program representation to analyze the impact of the changes. If no dependent units are affected, none are recompiled. In each case, conventional Ada compilers would recompile all dependent units.

Optimal recompilation happens automatically, whether you use the Rational Apex Ada editor or some other editor, such as emacs or vi. The larger and more complex your system, the more time and money you save with this unique Rational Apex feature.

Solves your problems of configuration management and version control

All information created and used throughout the project lifecycle is managed by Rational's system of configuration management and version control (CMVC). Unlike conventional systems, which manage only source code, CMVC manages all project information stored in the persistent program representation, and it captures and maintains information produced by third-party tools that are integrated with Rational Apex. With CMVC, vital information about changes is never garbled or lost, as in conventional systems.

CMVC lets you control parallel development paths where changes are allowed. Multiple developers or teams can work from the same baselined code and return their work to the baseline without interfering with or damaging each other's work. A change history is maintained for each unit, so you can revert to an earlier version when necessary. CMVC efficiently manages multiple generations of software-project deliverables.

Complete history and project reporting is available at the level of units, libraries, and configurations, improving management control. Rational's data integration avoids the problems of loosely integrated solutions and brings you productivity and quality gains throughout the software lifecycle.

Captures and enforces your architecture

Most Ada projects, even fairly small ones, consist of many Ada packages; large projects may include thousands of packages. Rational Subsystems(TM) generalize the Ada package concept to formalize and enforce relationships among components of your system on a scale much larger than that provided by Ada packages. Subsystems capture and express, in a manageable number of components, high-level structure that cannot be expressed directly in Ada.

Inadvertent or intentional violations of your architecture lead to errors, needless recompilations, and code that is hard to maintain. This phenomenon, known as architecture degradation, affects projects throughout the lifecycle, but it hits hardest when you have most of your code written and are close to integration testing and during downstream maintenance.

Like Ada packages, Rational Subsystems have a specification and an implementation. Subsystems make your system architecture visible to all developers. Each subsystem has a formal import and export list that determines how it can be used. Developers cannot add dependencies that have not been permitted already. Changes that affect the design are detected and reported, preventing architecture degradation.

Subsystems also introduce barriers that limit recompilation. A change in the implementation part of a subsystem does not affect dependent subsystems; without subsystems, such a change could cause cascading recompilations. Subsystems prevent this, drastically reducing system-build times.

Rational Apex CMVC and subsystems capabilities
help prevent architecture degradation.

Simplifies and accelerates system integration

CMVC and Rational Subsystems are integrated, so you can create and maintain multiple releases of a subsystem. You can combine and test variants of certain subsystems using a stable set of baseline subsystems, even as new versions are being developed. This prevents the risk inherent in postponing integration until far into the development lifecycle.

You specify which set of subsystem versions you want using a simple table-driven mechanism. You can compose and test subsystems in arbitrary combinations without recompilation in most cases. When recompilation is required, Rational Apex's unique optimal-recompilation technology dramatically reduces the amount of compilation necessary. You have complete flexibility, because you can go back to stable sets of components without penalty. Rational Apex significantly improves your testing throughput, because you avoid the expensive "recompile the world" rebuilds that lengthen project schedules.

Supports prototyping and simulation

Rational Apex's emphasis on interactive, rapid-turnaround operations gives you a low-risk, low-cost way of prototyping and simulating your design very early in the development lifecycle. This iterative development process, a key element of object technology, significantly reduces project risk and cost by identifying critical problems early in your development.

Simplifies postdeployment maintenance

After your system is released, development continues as bugs are discovered and new requirements are addressed. Subsystems enforce the original design, keeping the program maintainable by preventing changes that could drastically alter the system. CMVC maintains a complete history of the source, time, and reason for changes, so you can reliably reproduce each version of your code.

Works with all Ada compilers from all vendors

Rational Apex is a universal development environment, invaluable even when you are not deploying your code on an RS/6000 or a SPARC. Ada compilers from any vendor on any platform, targeting any processor, can be integrated with Rational Apex. All of the advantages of Rational Apex apply to any Ada project, no matter what Ada compiler you choose or migrate to in the future.

Rational Apex is tightly integrated with the industry's most extensive and capable family of Ada compilers, the VADS(R) product line. VADS is available for most host-system and embedded targets.

Offers open-systems interfaces for tool integration

Rational Apex is an OSF/Motif application and conforms to the Motif style guide. All Ada objects are stored as UNIX files or directories, so your knowledge of UNIX and its tools applies to Rational Apex. FrameViewer, which is bundled with Rational Apex, provides online help and a hypertext-linked version of the Reference Manual for the Ada Programming Language.

Rational Apex supports the industry-standard Ada Semantic Interface Specification (ASIS) programmatic interfaces. Based on software specifications that Rational donated to the ASIS effort, ASIS lets you build tools that manipulate Ada code without having to parse or semantically analyze it. Your tools therefore can be more reliable, more functional, and portable.

Every Rational Apex command is available through a set of command-line interfaces as well as the graphical user interface. The full set of UNIX commands, tools, and shell scripts can be combined with the Rational Apex command-line interfaces, so you can customize Rational Apex as required for your project.

Rational Apex, as a standard X/Motif
application, can be accessed from an X-terminal
or a Motif-compliant workstation or server.
Rational Apex itself can be used on powerful
servers, desktop workstations, or a mixture
of the two.

Brings you field-proven reliability

Rational Apex is the latest generation of the industry-leading Rational Environment(TM) first shipped in 1985. Rational Apex is used to develop and maintain itself and other Rational products totaling several million lines of Ada code. Other Rational software-engineering products include the Rational Compilation Integrator(TM), TestMate(TM), Rational Rose(R), SoDA(TM), and VADS. These products work with Rational Apex to provide solutions for analysis, design, requirements traceability, automatic document generation, target-code generation, and postdeployment maintenance. Rational Apex leads the industry in capability, completeness, and openness.